package Socketserver.Medium;

import Socketserver.SQL.ROOT;
import Socketserver.SQL.ForMysql;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.*;

public class Medium implements MediumAbstruct {
    // 初始化ROOT和ForMysql实例，用于数据库操作
    public ROOT root ;
    public ForMysql forMysql ;
    public Medium(){
        this.root = new ROOT();
        this.forMysql=new ForMysql(
                root.iT_CAN_MOVE_OR_NOT,
                root.getDriver(),
                root.getUrl(),
                root.getUsername(),
                root.getPassword(),
                root.getDATAABSE_NAME(),
                root.getThe_table_name(),
                root.getThe_TXTTable_name()
        );
        root.root_USE_SQL_ForOnly_CREATEDATABASE();
        root.root_create_SQL_table();
        root.root_create_SQLTXT_table();
    }

    /**
     * Medium级方法：用户登录
     * @param password 登录密码
     * @param type 账号类型（user/admin）
     * @return 登录成功返回true，失败返回false
     * 处理流程：
     * 1. 验证密码和类型非空
     * 2. 根据密码查询用户表，获取匹配记录
     * 3. 验证记录中的账号类型是否匹配
     */
    @Override
    public boolean Medium_POWER_login(String password, String type) {
        if (password == null || password.trim().isEmpty() || type == null || type.trim().isEmpty()) {
            System.out.println("登录失败：密码或账号类型不能为空");
            return false;
        }

        // 根据密码查询用户（精确匹配密码）
        List<Map<String, String>> result = forMysql.SELECT_FROM_FIND_MY_Account(password, root.getTable_password());
        if (result == null || result.isEmpty()) {
            System.out.println("登录失败：密码错误");
            return false;
        }

        // 验证账号类型是否匹配
        for (Map<String, String> user : result) {
            if (type.equals(user.get(root.getTable_type()))) {
                System.out.println("登录成功：账号类型匹配");
                return true;
            }
        }

        System.out.println("登录失败：账号类型不匹配");
        return false;
    }


    /**
     * Medium级方法：用户注册
     * @param name 用户名
     * @param password 密码（至少6位）
     * @param type 账号类型（user/admin）
     * @return 注册成功返回true，失败返回false
     * 处理流程：
     * 1. 验证参数合法性（用户名非空、密码长度、类型合法）
     * 2. 检查用户名是否已存在
     * 3. 生成唯一用户ID，插入数据库（非root用户）
     */
    @Override
    public boolean Medium_POWER_register(String name, String password, String type) {
        if (name == null || name.trim().isEmpty()) {
            System.out.println("注册失败：用户名不能为空");
            return false;
        }
        if (password == null || password.length() < 6) {
            System.out.println("注册失败：密码长度不能少于6位");
            return false;
        }
        if (type == null || (!"user".equals(type) && !"admin".equals(type))) {
            System.out.println("注册失败：账号类型必须为'user'或'admin'");
            return false;
        }

        // 检查用户名是否已存在（模糊查询用户名）
        List<Map<String, String>> existingUsers = forMysql.SELECT_FROM_FIND_MY_Account(name, root.getTable_name());
        if (existingUsers != null && !existingUsers.isEmpty()) {
            System.out.println("注册失败：用户名已存在");
            return false;
        }

        // 生成UUID作为用户ID
        String userId = UUID.randomUUID().toString().replace("-", "");
        // 插入用户表（is_root=0表示非管理员）
        boolean insertResult = forMysql.INSERT_INTO_TABLE_User(userId, name, password, type, 0);

        if (insertResult) {
            System.out.println("注册成功：用户ID=" + userId);
        } else {
            System.out.println("注册失败：数据库插入异常");
        }
        return insertResult;
    }


    /**
     * User级方法：指定ID添加用户（需权限）
     * @param USER_id 自定义用户ID
     * @param name 用户名
     * @param password 密码（至少6位）
     * @param type 账号类型（user/admin）
     * @return 添加成功返回true，失败返回false
     * 处理流程：
     * 1. 验证用户ID非空且未被占用
     * 2. 验证用户名、密码、类型合法性
     * 3. 插入数据库（非root用户）
     */
    @Override
    public boolean User_POWER_ADD_Account_(String USER_id, String name, String password, String type) {
        if (USER_id == null || USER_id.trim().isEmpty()) {
            System.out.println("添加账号失败：用户ID不能为空");
            return false;
        }

        // 检查ID是否已存在（精确查询ID）
        List<Map<String, String>> existing = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
        if (existing != null && !existing.isEmpty()) {
            System.out.println("添加账号失败：ID已存在");
            return false;
        }

        // 验证其他参数
        if (name == null || name.trim().isEmpty() || password == null ) {
            System.out.println("添加账号失败：用户名或密码不合法");
            return false;
        }
        if (type == null) {
            System.out.println("添加账号失败：账号类型不合法");
            return false;
        }

        // 插入用户表（is_root=0）
        boolean result = forMysql.INSERT_INTO_TABLE_User(USER_id, name, password, type, 0);
        System.out.println(result ? "账号添加成功" : "账号添加失败：数据库操作异常");
        return result;
    }


    /**
     * User级方法：添加文本作品
     * @param USER_id 操作用户ID（需存在）
     * @param TXT_name 文本名称
     * @param author 作者（通常为USER_id）
     * @param File_byte 文本文件字节数组
     * @return 添加成功返回true，失败返回false
     * 处理流程：
     * 1. 验证用户ID存在
     * 2. 验证文本参数非空
     * 3. 生成文本ID，保存文件到本地
     * 4. 插入文本表记录
     */
    @Override
    public boolean User_POWER_ADD_TXT_(String USER_id, String TXT_name, String author, byte[] File_byte) {
        // 验证用户是否存在
        List<Map<String, String>> user = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
        if (user == null || user.isEmpty()) {
            System.out.println("添加作品失败：用户ID不存在");
            return false;
        }

        // 验证文本参数
        if (TXT_name == null || TXT_name.trim().isEmpty() || author == null || File_byte == null || File_byte.length == 0) {
            System.out.println("添加作品失败：参数不能为空");
            return false;
        }

        // 生成文本唯一ID
        String txtId = UUID.randomUUID().toString().replace("-", "");
        // 定义文件保存路径（实际使用时建议修改为动态路径）
        //【有问题 我们应该用 相对地址System.getProperty("user.dir");  】
        String basePath = System.getProperty("user.dir")+"\\src\\aTXT_pagage\\";
        Path filePath = Paths.get(basePath + TXT_name);

        try {
            // 确保父目录存在
            Files.createDirectories(filePath.getParent());
            // 写入文件
            Files.write(filePath, File_byte);
            // 将byte[]写入目标文件
//            try (FileOutputStream fos = new FileOutputStream(
//                    //targetFile
//                    new File("D:\\a_E\\桌面\\IdeaProjects\\IdeaProjects\\WHAT_JAVA_HOMEWORK_FOR_CLASS\\src\\aTXT_pagage\\TXT.txt")
//            )) {
//                fos.write(File_byte); // 一次性写入全部字节
//                // 强制刷新到磁盘（小文件可选，大文件不建议频繁刷新）
//                fos.flush();
//                System.out.println("文件已通过byte[]复制完成！");
//            } catch (IOException e) {
//                System.out.println("写入目标文件失败：" + e.getMessage());
//                e.printStackTrace();
//            }
            //
            System.out.println("文件保存成功：" + filePath);
        } catch (IOException e) {
            System.out.println("文件保存失败：" + e.getMessage());
            return false;
        }

        // 插入文本表
        boolean dbResult = forMysql.INSERT_INTO_TABLE_txt(txtId, TXT_name, filePath.toString(), author);
        System.out.println(dbResult ? "作品添加成功：TXT_ID=" + txtId : "作品添加失败：数据库操作异常");
        return dbResult;
    }
    public void User_POWER_ADD_TXT_WRITE(String new_name,byte[] fileBytes){
        // 将byte[]写入目标文件
        try (FileOutputStream fos = new FileOutputStream(
                //targetFile
                new File(System.getProperty("user.dir")+"\\src\\aTXT_pagage\\"+new_name)
        )) {
            fos.write(fileBytes); // 一次性写入全部字节
            // 强制刷新到磁盘（小文件可选，大文件不建议频繁刷新）
            fos.flush();
            System.out.println("文件已通过byte[]复制完成！");
        } catch (IOException e) {
            System.out.println("写入目标文件失败：" + e.getMessage());
            e.printStackTrace();
        }
    }


    /**
     * User级方法：删除自己的账号
     * @param USER_id 要删除的用户ID
     * @return 删除成功返回true，失败返回false
     * 处理流程：
     * 1. 验证用户ID非空且存在
     * 2. 执行数据库删除操作
     */
    @Override
    public boolean User_POWER_DELETE_Account_(String USER_id) {
        if (USER_id == null || USER_id.trim().isEmpty()) {
            System.out.println("删除账号失败：用户ID不能为空");
            return false;
        }

        // 验证用户存在
        List<Map<String, String>> user = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
        if (user == null || user.isEmpty()) {
            System.out.println("删除账号失败：用户ID不存在");
            return false;
        }

        // 执行删除（按ID精确删除）
        boolean result = forMysql.DELETE_TABLE_User_What(root.getTable_id(), USER_id);
        System.out.println(result ? "账号删除成功" : "账号删除失败：数据库操作异常");
        return result;
    }


    /**
     * User级方法：删除自己的文案
     * @param TXT_ID 要删除的文本ID
     * @param USER_id 操作用户ID（需为文本作者）
     * @return 删除成功返回true，失败返回false
     * 处理流程：
     * 1. 验证参数非空
     * 2. 验证用户和文本存在
     * 3. 验证用户为文本作者（权限检查）
     * 4. 删除本地文件和数据库记录
     */
    @Override
    public boolean User_POWER_DELETE_TXT_(String TXT_ID, String USER_id) {
        if (TXT_ID == null || TXT_ID.trim().isEmpty() || USER_id == null || USER_id.trim().isEmpty()) {
            System.out.println("删除文案失败：参数不能为空");
            return false;
        }

        // 验证用户存在
        List<Map<String, String>> user = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
        if (user == null || user.isEmpty()) {
            System.out.println("删除文案失败：用户ID不存在");
            return false;
        }

        // 验证文本存在
        List<Map<String, String>> txt = forMysql.SELECT_FROM_FIND_MY_TXT(TXT_ID, root.getTXT_TABLE_id());
        if (txt == null || txt.isEmpty()) {
            System.out.println("删除文案失败：文本ID不存在");
            return false;
        }

        // 验证权限（必须是本人作品）
        String txtAuthor = txt.get(0).get(root.getTXT_TABLE_author());
        if (!USER_id.equals(txtAuthor)) {
            System.out.println("删除文案失败：无权限（非本人作品）");
            return false;
        }

        // 删除本地文件
        String txtPath = txt.get(0).get(root.getTXT_TABLE_address());
        try {
            if (Files.exists(Paths.get(txtPath))) {
                Files.delete(Paths.get(txtPath));
                System.out.println("文件删除成功：" + txtPath);
            }
        } catch (IOException e) {
            System.out.println("文件删除失败：" + e.getMessage());
        }

        // 删除数据库记录（按ID精确删除）
        boolean dbResult = forMysql.DELETE_TABLE_txt_What(root.getTXT_TABLE_id(), TXT_ID, USER_id);
        System.out.println(dbResult ? "文案删除成功" : "文案删除失败：数据库操作异常");
        return dbResult;
    }


    /**
     * User级方法：修改自己的账号信息
     * @param USER_id 操作用户ID
     * @param key 要修改的字段（name/password/type）
     * @param value 字段新值
     * @return 修改成功返回true，失败返回false
     * 处理流程：
     * 1. 验证参数非空
     * 2. 验证用户存在
     * 3. 限制可修改字段（禁止修改id和is_root）
     * 4. 验证新值合法性（密码长度、类型范围）
     * 5. 执行数据库更新
     */
    @Override
    public boolean User_POWER_UPDATE_Account_(String USER_id, String key, String value) {
        // 验证参数非空
        if (USER_id == null || USER_id.trim().isEmpty()) {
            System.out.println("修改账号失败：用户ID不能为空");
            return false;
        }
        if (key == null || key.trim().isEmpty()) {
            System.out.println("修改账号失败：修改的字段名不能为空");
            return false;
        }
        if (value == null || value.trim().isEmpty()) {
            System.out.println("修改账号失败：新值不能为空");
            return false;
        }

        // 验证用户存在
        List<Map<String, String>> userList = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
        if (userList == null || userList.isEmpty()) {
            System.out.println("修改账号失败：用户ID不存在");
            return false;
        }
        Map<String, String> user = userList.get(0);

        // 限制可修改字段（仅name/password/type）
        List<String> allowUpdateFields = new ArrayList<>();
        allowUpdateFields.add(root.getTable_name());      // name字段
        allowUpdateFields.add(root.getTable_password());  // password字段
        allowUpdateFields.add(root.getTable_type());      // type字段
        if (!allowUpdateFields.contains(key)) {
            System.out.println("修改账号失败：不允许修改字段[" + key + "]（仅支持name、password、type）");
            return false;
        }

        // 验证新值合法性
        if (key.equals(root.getTable_password()) && value.length() < 6) {
            System.out.println("修改账号失败：密码长度不能少于6位");
            return false;
        }
        if (key.equals(root.getTable_type()) && !"user".equals(value) && !"admin".equals(value)) {
            System.out.println("修改账号失败：类型必须为'user'或'admin'");
            return false;
        }

        // 获取字段旧值（用于精准匹配）
        String oldValue = user.get(key);
        if (oldValue == null) {
            System.out.println("修改账号失败：字段[" + key + "]不存在");
            return false;
        }

        // 执行更新（通过ID和旧值双重匹配，确保修改自己的记录）
        boolean updateResult = forMysql.ALTER_TABLE_User_What(USER_id, key, oldValue, value);
        System.out.println(updateResult ? "账号修改成功" : "账号修改失败：数据库异常");
        return updateResult;
    }


    /**
     * User级方法：修改自己的文案（仅名称和作者）
     * @param USER_id 操作用户ID（需为作者）
     * @param TXT_key 格式为"文本ID:字段名"（字段名：TXT_name/TXT_author）
     * @param TXT_value 字段新值
     * @return 修改成功返回true，失败返回false
     * 处理流程：
     * 1. 验证参数非空
     * 2. 解析TXT_key获取文本ID和字段名
     * 3. 验证用户和文本存在，且用户为作者
     * 4. 限制可修改字段（禁止修改ID和地址）
     * 5. 执行数据库更新
     */
    @Override
    public boolean User_POWER_UPDATE_TXT_(String USER_id, String TXT_key, String TXT_value) {
        // 验证参数非空
        if (USER_id == null || USER_id.trim().isEmpty()) {
            System.out.println("修改文案失败：用户ID不能为空");
            return false;
        }
        if (TXT_key == null || TXT_key.trim().isEmpty() || TXT_value == null || TXT_value.trim().isEmpty()) {
            System.out.println("修改文案失败：字段名或新值不能为空");
            return false;
        }

        // 解析TXT_key（格式："TXT_id:字段名"）
        String[] keyParts = TXT_key.split(":", 2);
        if (keyParts.length != 2) {
            System.out.println("修改文案失败：格式错误（正确：TXT_id:字段名）");
            return false;
        }
        String txtId = keyParts[0];  // 文本ID
        String field = keyParts[1];  // 要修改的字段

        // 验证用户存在
        List<Map<String, String>> user = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
        if (user == null || user.isEmpty()) {
            System.out.println("修改文案失败：用户ID不存在");
            return false;
        }

        // 验证文本存在
        List<Map<String, String>> txt = forMysql.SELECT_FROM_FIND_MY_TXT(txtId, root.getTXT_TABLE_id());
        if (txt == null || txt.isEmpty()) {
            System.out.println("修改文案失败：文本ID不存在");
            return false;
        }
        Map<String, String> txtInfo = txt.get(0);

        // 验证权限（必须是本人作品）
        String txtAuthor = txtInfo.get(root.getTXT_TABLE_author());
        if (!USER_id.equals(txtAuthor)) {
            System.out.println("修改文案失败：无权限（非本人作品）");
            return false;
        }

        // 限制可修改字段（仅TXT_name/TXT_author，禁止修改地址和ID）
        List<String> allowFields = new ArrayList<>();
        allowFields.add(root.getTXT_TABLE_name());    // TXT_name字段
        allowFields.add(root.getTXT_TABLE_author());  // TXT_author字段
        if (!allowFields.contains(field)) {
            System.out.println("修改文案失败：不允许修改字段[" + field + "]（仅支持名称和作者）");
            return false;
        }

        // 获取字段旧值（用于精准匹配）
        String oldValue = txtInfo.get(field);
        if (oldValue == null) {
            System.out.println("修改文案失败：字段[" + field + "]不存在");
            return false;
        }

        // 执行更新
        boolean updateResult = forMysql.ALTER_TABLE_txt_What(field, oldValue, TXT_value);
        System.out.println(updateResult ? "文案修改成功" : "文案修改失败：数据库异常");
        return updateResult;
    }


    /**
     * User级方法：查询自己的账号信息
     * @param USER_id 操作用户ID
     * @return 账号信息列表（仅自己的记录），无数据返回空列表
     * 处理流程：
     * 1. 验证用户ID非空
     * 2. 按ID精确查询用户表
     * 3. 返回查询结果（敏感信息已被ForMysql隐藏）
     */
    @Override
    public List<Map<String, String>> User_POWER_SELECT_FROM_user_(String USER_id) {
        if (USER_id == null || USER_id.trim().isEmpty()) {
            System.out.println("查询账号失败：用户ID不能为空");
            return new ArrayList<>();
        }

        // 按ID精确查询自己的信息
        List<Map<String, String>> userInfo = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
        if (userInfo == null || userInfo.isEmpty()) {
            System.out.println("查询账号失败：用户ID不存在");
            return new ArrayList<>();
        }

        System.out.println("查询账号成功：返回用户ID=" + USER_id + "的信息");
        return userInfo;
    }


    /**
     * User级方法：查询自己创建的所有文案
     * @param USER_id 操作用户ID（作为作者）
     * @return 文案列表（仅自己的作品），无数据返回空列表
     * 处理流程：
     * 1. 验证用户ID非空且存在
     * 2. 按作者字段查询文本表（匹配USER_id）
     * 3. 返回查询结果（敏感信息已被ForMysql隐藏）
     */
    @Override
    public List<Map<String, String>> User_POWER_SELECT_FROM_txt_(String USER_id) {
        if (USER_id == null || USER_id.trim().isEmpty()) {
            System.out.println("查询文案失败：用户ID不能为空");
            return new ArrayList<>();
        }

        // 验证用户存在
        List<Map<String, String>> user = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
        if (user == null || user.isEmpty()) {
            System.out.println("查询文案失败：用户ID不存在");
            return new ArrayList<>();
        }

        // 按作者查询自己的文案（TXT_author=USER_id）
        List<Map<String, String>> myTxts = forMysql.SELECT_FROM_FIND_MY_TXT(USER_id, root.getTXT_TABLE_author());
        if (myTxts.isEmpty()) {
            System.out.println("查询文案结果：该用户暂无作品");
        } else {
            System.out.println("查询文案成功：返回" + myTxts.size() + "条记录");
        }
        return myTxts;
    }

    @Override
    public Map<String, Object> User_POWER_SELECT_TXT_BY_PAGE(String USER_id, String TXT_ID, int pageNum, int pageSize) {
        // 初始化返回结果（使用HashMap保证可修改，替代不可变的Map.of()）

        Map<String, Object> result = new HashMap<>();
        try {
            // 1. 基础参数合法性校验
            if (USER_id == null || USER_id.trim().isEmpty()) {
                result.put("success", false);
                result.put("msg", "用户ID不能为空");
                return result;
            }
            if (TXT_ID == null || TXT_ID.trim().isEmpty()) {
                result.put("success", false);
                result.put("msg", "文本ID不能为空");
                return result;
            }
            if (pageNum < 1) {
                result.put("success", false);
                result.put("msg", "页码必须从1开始");
                return result;
            }
            if (pageSize <= 0) {
                result.put("success", false);
                result.put("msg", "每页字节数必须大于0");
                return result;
            }

            // 2. 校验用户是否存在
            List<Map<String, String>> user = forMysql.SELECT_FROM_FIND_MY_Account(USER_id, root.getTable_id());
            if (user == null || user.isEmpty()) {
                result.put("success", false);
                result.put("msg", "用户ID不存在");
                return result;
            }

            // 3. 校验文本是否存在并获取文本信息
            List<Map<String, String>> txtList = forMysql.SELECT_FROM_FIND_MY_TXT(TXT_ID, root.getTXT_TABLE_id());
            if (txtList == null || txtList.isEmpty()) {
                result.put("success", false);
                result.put("msg", "文本ID不存在");
                return result;
            }
            Map<String, String> txtInfo = txtList.get(0);
            String txtAuthor = txtInfo.get(root.getTXT_TABLE_author());
            String txtPath = txtInfo.get(root.getTXT_TABLE_address());
            String txtName = txtInfo.get(root.getTXT_TABLE_name());

            // 4. 权限校验：普通用户只能查看自己的文章，Root可查看所有
            if (!isRoot(USER_id) && !USER_id.equals(txtAuthor)) {
                result.put("success", false);
                result.put("msg", "无权限：仅作者或Root可查看该文章");
                return result;
            }

            // 5. 校验文章文件是否存在
            File txtFile = new File(txtPath);
            if (!txtFile.exists() || !txtFile.isFile()) {
                result.put("success", false);
                result.put("msg", "文章文件不存在：" + txtPath);
                return result;
            }

            // 6. 计算分页核心参数
            long totalBytes = txtFile.length(); // 文件总字节数
            int totalPages = (int) Math.ceil((double) totalBytes / pageSize); // 总页数（向上取整）
            if (pageNum > totalPages) { // 页码超出范围校验
                result.put("success", false);
                result.put("msg", "页码超出范围，总页数为：" + totalPages);
                return result;
            }
            // 计算当前页的字节读取区间
            long startByte = (pageNum - 1) * pageSize;
            long endByte = Math.min(startByte + pageSize, totalBytes);
            int readLength = (int) (endByte - startByte);

            // 7. 分段读取文件内容（UTF-8编码避免控制台乱码）
            byte[] buffer = new byte[readLength];
            try (FileInputStream fis = new FileInputStream(txtFile)) {
                fis.skip(startByte); // 跳过起始字节前的内容
                fis.read(buffer, 0, readLength); // 读取当前页字节
            }
            String content = new String(buffer, StandardCharsets.UTF_8);

            // 8. 封装控制台所需的结果数据（精简核心参数）
            result.put("success", true);
            result.put("content", content);       // 当前页核心内容（控制台打印重点）
            result.put("pageNum", pageNum);       // 当前页码
            result.put("totalPages", totalPages); // 总页数
            result.put("txtName", txtName);       // 文章名称（控制台标题）
            result.put("txtAuthor", txtAuthor);   // 文章作者（控制台标题）
            result.put("hasNext", pageNum < totalPages); // 是否有下一页（控制台交互）
            result.put("hasPrev", pageNum > 1);   // 是否有上一页（控制台交互）
            result.put("msg", "查询成功");

        } catch (Exception e) {
            // 统一捕获异常并封装错误信息
            result.put("success", false);
            result.put("msg", "分段查看失败：" + e.getMessage());
            e.printStackTrace(); // 控制台打印异常栈，便于调试
        }
        return result;
    }
    /**
     * 测试工具方法：执行分段查看并打印结果
     */
    public void User_POWER_SELECT_TXT_BY_PAGETestSegmentView(Medium medium, String userId, String txtId, int pageNum, int pageSize) {
        Map<String, Object> result = medium.User_POWER_SELECT_TXT_BY_PAGE(userId, txtId, pageNum, pageSize);
        boolean success = (boolean) result.get("success");
        if (success) {
            System.out.println("文章名称：" + result.get("txtName"));
            System.out.println("当前页：" + result.get("pageNum") + " / 总页数：" + result.get("totalPages"));
            System.out.println("当前页内容（字节数：" + ((String) result.get("content")).getBytes(StandardCharsets.UTF_8).length + "）：");
            System.out.println(result.get("content"));
            System.out.println("是否有下一页：" + result.get("hasNext") + " | 是否有上一页：" + result.get("hasPrev"));
        } else {
            System.out.println("失败原因：" + result.get("msg"));
        }
    }


    /**
     * Root级方法：格式化表（删除并重建用户表和文本表）
     * @param ROOT_id 管理员ID（需验证权限）
     * 处理流程：
     * 1. 验证ROOT_id为管理员（is_root=1）
     * 2. 删除用户表和文本表
     * 3. 重建用户表和文本表
     */
    @Override
    public void ROOT_POWER_RESTART(String ROOT_id) {
        // 验证root权限
        if (!isRoot(ROOT_id)) {
            System.out.println("格式化失败：无root权限");
            return;
        }

        // 删除表
        root.root_drop_SQL_table();         // 删除用户表
        root.root_drop_SQLTXT_table();      // 删除文本表
        try {
            Thread.sleep(500); // 延迟确保删除完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 重建表
        root.root_create_SQL_table();       // 重建用户表
        root.root_create_SQLTXT_table();    // 重建文本表
        System.out.println("ROOT格式化成功：用户表和文本表已重建");
    }


    /**
     * Root级方法：删除指定用户
     * @param ROOT_id 管理员ID（需验证权限）
     * @param User_key 筛选字段（如id/name）
     * @param User_value 筛选值
     * 处理流程：
     * 1. 验证root权限
     * 2. 调用ROOT类方法按条件删除用户
     */
    @Override
    public void ROOT_POWER_DELETE_user_(String ROOT_id, String User_key, String User_value) {
        if (!isRoot(ROOT_id)) {
            System.out.println("删除用户失败：无root权限");
            return;
        }

        if (User_key == null || User_key.trim().isEmpty() || User_value == null) {
            System.out.println("删除用户失败：字段名或值不能为空");
            return;
        }

        // 调用ROOT类的删除方法（按字段条件删除）
        root.root_drop_SQL_table_FORUser(User_value, User_key);
        System.out.println("ROOT删除用户完成：按[" + User_key + "=" + User_value + "]删除");
    }


    /**
     * Root级方法：删除指定文案（含本地文件）
     * @param ROOT_id 管理员ID（需验证权限）
     * @param TXT_key 筛选字段（如TXT_id/TXT_name）
     * @param TXT_value 筛选值
     * 处理流程：
     * 1. 验证root权限
     * 2. 查询符合条件的文案，删除本地文件
     * 3. 调用ROOT类方法删除数据库记录
     */
    @Override
    public void ROOT_POWER_DELETE_txt_(String ROOT_id, String TXT_key, String TXT_value) {
        if (!isRoot(ROOT_id)) {
            System.out.println("删除文案失败：无root权限");
            return;
        }

        if (TXT_key == null || TXT_key.trim().isEmpty() || TXT_value == null) {
            System.out.println("删除文案失败：字段名或值不能为空");
            return;
        }

        // 先查询符合条件的文案，删除本地文件
        List<Map<String, String>> txts = forMysql.SELECT_FROM_FIND_MY_TXT(TXT_value, TXT_key);
        for (Map<String, String> txt : txts) {
            String txtPath = txt.get(root.getTXT_TABLE_address());
            try {
                if (Files.exists(Paths.get(txtPath))) {
                    Files.delete(Paths.get(txtPath));
                    System.out.println("ROOT删除文件：" + txtPath);
                }
            } catch (IOException e) {
                System.out.println("ROOT删除文件失败：" + e.getMessage());
            }
        }

        // 调用ROOT类的删除方法（按字段条件删除）
        root.root_drop_SQL_table_FORTxt(TXT_value, TXT_key);
        System.out.println("ROOT删除文案完成：按[" + TXT_key + "=" + TXT_value + "]删除");
    }


    /**
     * Root级方法：修改文案（删除旧记录+插入新记录）
     * @param ROOT_id 管理员ID（需验证权限）
     * @param TXT_key 格式为"旧TXT_id:新名称:新作者"
     * @param TXT_value 新文件地址
     * 处理流程：
     * 1. 验证root权限
     * 2. 解析参数获取旧ID、新名称、新作者、新地址
     * 3. 删除旧文案（含文件）
     * 4. 插入新文案记录
     */
    @Override
    public void ROOT_POWER_UPDATE_txt_(String ROOT_id, String TXT_key, String TXT_value) {
        if (!isRoot(ROOT_id)) {
            System.out.println("修改文案失败：无root权限");
            return;
        }

        // 解析参数（格式：旧TXT_id:新名称:新作者）
        String[] parts = TXT_key.split(":", 3);
        if (parts.length != 3) {
            System.out.println("修改文案失败：格式错误（正确：旧TXT_id:新名称:新作者）");
            return;
        }
        String oldTxtId = parts[0];   // 旧文本ID
        String newName = parts[1];    // 新名称
        String newAuthor = parts[2];  // 新作者
        String newAddress = TXT_value; // 新地址

        // 先删除旧文案
        ROOT_POWER_DELETE_txt_(ROOT_id, root.getTXT_TABLE_id(), oldTxtId);

        // 插入新文案（生成新ID）
        String newTxtId = UUID.randomUUID().toString().replace("-", "");
        boolean insertResult = forMysql.INSERT_INTO_TABLE_txt(newTxtId, newName, newAddress, newAuthor);
        System.out.println(insertResult ? "ROOT修改文案成功" : "ROOT修改文案失败：插入新记录异常");
    }


    /**
     * Root级方法：修改用户（删除旧记录+插入新记录）
     * @param ROOT_id 管理员ID（需验证权限）
     * @param User_key 格式为"旧ID:新名称:新类型"
     * @param User_value 新密码
     * 处理流程：
     * 1. 验证root权限
     * 2. 解析参数获取旧ID、新名称、新类型、新密码
     * 3. 删除旧用户
     * 4. 插入新用户记录
     */
    @Override
    public void ROOT_POWER_UPDATA_user_(String ROOT_id, String User_key, String User_value) {
        if (!isRoot(ROOT_id)) {
            System.out.println("修改用户失败：无root权限");
            return;
        }

        // 解析参数（格式：旧ID:新名称:新类型）
        String[] parts = User_key.split(":", 3);
        if (parts.length != 3) {
            System.out.println("修改用户失败：格式错误（正确：旧ID:新名称:新类型）");
            return;
        }
        String oldUserId = parts[0];  // 旧用户ID
        String newName = parts[1];    // 新名称
        String newType = parts[2];    // 新类型
        String newPassword = User_value; // 新密码

        // 先删除旧用户
        ROOT_POWER_DELETE_user_(ROOT_id, root.getTable_id(), oldUserId);

        // 插入新用户（生成新ID）
        String newUserId = UUID.randomUUID().toString().replace("-", "");
        boolean insertResult = forMysql.INSERT_INTO_TABLE_User(newUserId, newName, newPassword, newType, 0);
        System.out.println(insertResult ? "ROOT修改用户成功" : "ROOT修改用户失败：插入新记录异常");
    }


    /**
     * Root级方法：查询所有用户（支持条件筛选）
     * @param USER_id 管理员ID（需验证权限）
     * @param User_key 筛选字段（如id/name，可为空）
     * @param User_value 筛选值（可为空）
     * @return 用户列表，无数据返回空列表
     * 处理流程：
     * 1. 验证root权限
     * 2. 调用ROOT类方法按条件查询用户表
     */
    @Override
    public List<Map<String, String>> ROOT_POWER_SELECT_FROM_user_(String USER_id, String User_key, String User_value) {
        if (!isRoot(USER_id)) {
            System.out.println("查询用户失败：无root权限");
            return new ArrayList<>();
        }

        // 调用ROOT类的全表查询方法
        List<Map<String, String>> users = root.SELECT_TABLE_FOR_ALL_Table_rootss(
                root.getThe_table_name(),  // 用户表名
                User_key,                  // 筛选字段
                User_value                 // 筛选值
        );
        System.out.println("ROOT查询用户结果：" + users.size() + "条记录");
        return users;
    }
    public List<Map<String, String>> ROOT_POWER_SELECT_FROM_user_FORGET(String USER_id, String User_key, String User_value) {
        //用于注册用户
        if(USER_id.equals("root")){
            System.out.print(" ");
        }else{
            return new ArrayList<>();
        }

        // 调用ROOT类的全表查询方法
        List<Map<String, String>> users = root.SELECT_TABLE_FOR_ALL_Table_rootss(
                root.getThe_table_name(),  // 用户表名
                User_key,                  // 筛选字段
                User_value                 // 筛选值
        );
        System.out.println("ROOT查询用户结果：" + users.size() + "条记录");
        return users;
    }

    /**
     * Root级方法：查询所有文案（支持条件筛选）
     * @param USER_id 管理员ID（需验证权限）
     * @param TXT_key 筛选字段（如TXT_id/TXT_name，可为空）
     * @param TXT_value 筛选值（可为空）
     * @return 文案列表，无数据返回空列表
     * 处理流程：
     * 1. 验证root权限
     * 2. 调用ROOT类方法按条件查询文本表
     */
    @Override
    public List<Map<String, String>> ROOT_POWER_SELECT_FROM_txt_(String USER_id, String TXT_key, String TXT_value) {
        if (!isRoot(USER_id)) {
            System.out.println("查询文案失败：无root权限");
            return new ArrayList<>();
        }

        // 调用ROOT类的全表查询方法
        List<Map<String, String>> txts = root.SELECT_TABLE_FOR_ALL_Table_rootss(
                root.getThe_TXTTable_name(),  // 文本表名
                TXT_key,                      // 筛选字段
                TXT_value                     // 筛选值
        );
        System.out.println("ROOT查询文案结果：" + txts.size() + "条记录");
        return txts;
    }
    public List<Map<String, String>> ROOT_POWER_SELECT_FROM_txt_FORGET(String USER_id, String TXT_key, String TXT_value) {
        if (!USER_id.equals("root")) {
            System.out.println("查询文案失败：无root权限");
            return new ArrayList<>();
        }

        // 调用ROOT类的全表查询方法
        List<Map<String, String>> txts = root.SELECT_TABLE_FOR_ALL_Table_rootss(
                root.getThe_TXTTable_name(),  // 文本表名
                TXT_key,                      // 筛选字段
                TXT_value                     // 筛选值
        );
        System.out.println("ROOT查询文案结果：" + txts.size() + "条记录");
        return txts;
    }

    /**
     * 辅助方法：验证用户是否为root管理员
     * @param userId 待验证的用户ID
     * @return 是管理员返回true，否则返回false
     */
    private boolean isRoot(String userId) {
        if (userId == null || userId.trim().isEmpty()) {
            return false;
        }

        // 查询用户的is_root字段（1表示管理员）
        List<Map<String, String>> rootUser = forMysql.SELECT_FROM_FIND_MY_Account(userId, root.getTable_id());
        if (rootUser == null || rootUser.isEmpty()) {
            return false;
        }

        String isRoot = rootUser.get(0).get(root.getTable_root_());
        return "1".equals(isRoot);
    }
}